package com.kiven.singleton;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/*
 * 参考信息
 * http://xupo.iteye.com/blog/463426
 */

public class ConnectionUtil {
	/** 第一种单例模式： 普通的单例模式 */
	/*
	 * 这样的代码缺点是：第一次加载类的时候会连带着创建Singleton实例，这样的结果与我们所期望的不同，
	 * 因为创建实例的时候可能并不是我们需要这个实例的时候。
	 * 同时如果这个Singleton实例的创建非常消耗系统资源，而应用始终都没有使用Singleton实例，
	 * 那么创建Singleton消耗的系统资源就被白白浪费了。
	 * 
	 * private static ConnectionUtil instance = new ConnectionUtil();
	 * 
	 * private ConnectioinUtil(){}
	 * 
	 * public static ConnectionUtil getInstance() {
	 * 		return instance;	
	 * }
	 * 
	 */
	
	/** 第二种单例模式： 惰性加载 */
	/*
	 * private static ConnectionUtil instance = null;
	 * 
	 * private ConnectioinUtil(){}
	 * 
	 * public static ConnectionUtil getInstance() {
	 * 		if (instance == null) {
	 * 			instance = new ConnectionUtil();	
	 * 		}
	 * 
	 * 		return instance;
	 * }
	 * 
	 */
	/** 第三种单例模式： 惰性加载 考虑多线程安全 Double-check locking*/
	/*
	 *  让我们来看一下这个代码是如何工作的：首先当一个线程发出请求后，会先检查instance是否为null，
	 *  如果不是则直接返回其内容，这样避免了进入synchronized块所需要花费的资源。
	 *  其次，即使第2节提到的情况发生了，两个线程同时进入了第一个if判断，那么他们也
	 *  必须按照顺序执行synchronized块中的代码，第一个进入代码块的线程会创建一个新
	 *  的Singleton实例，而后续的线程则因为无法通过if判断，而不会创建多余的实例。
	 *  上述描述似乎已经解决了我们面临的所有问题，但实际上，从JVM的角度讲，这些代码仍然可能发生错误。
	 *  
	 *  对于JVM而言，它执行的是一个个Java指令。在Java指令中创建对象和赋值操作是分开进行的，
	 *  也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，
	 *  也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，
	 *  然后再去初始化这个Singleton实例。这样就使出错成为了可能，我们仍然以A、B两个线程为例：
	 *  
	 *  1.A、B线程同时进入了第一个if判断
	 *  2.A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
	 *  3.由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，
	 *  并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。
	 *  4.B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
	 *  5.此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。
	 *  4.通过内部类实现多线程环境中的单例模式
	 * 
	 * 
	 * private static ConnectionUtil instance = null;
	 * 
	 * private ConnectioinUtil(){}
	 * 
	 * public static ConnectionUtil getInstance() {
	 * 		if (instance == null) {
	 * 			synchronized (instance) {
	 * 				if (instance == null) {
	 * 					instance = new ConnectionUtil();
	 * 				}
	 * 			}	
	 * 		}
	 * 
	 * 		return instance;
	 * }
	 * 
	 */
	
	/** 单例模式的最佳实现方式 */
	/* 
	 * JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。
	 * 这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，
	 * 并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心Double-check locking中的问题。
	 * 此外该方法也只会在第一次调用的时候使用互斥机制，这样就解决了3.1中的低效问题。
	 * 最后instance是在第一次加载SingletonContainer类时被创建的，而SingletonContainer
	 * 类则在调用getInstance方法的时候才会被加载，因此也实现了惰性加载。
	 * 
	 */
	private Connection conn = null;
	
	private ConnectionUtil() {
		String driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
		String url = "jdbc:sqlserver://localhost:1433;DataBaseName = YFL1TO3";
		String user = "omlogin";
		String password = "ulstek";
		
		try {
			Class.forName(driver);
			conn = DriverManager.getConnection(url, user, password);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	private static class SingletonContainer {
		private static ConnectionUtil instance = new ConnectionUtil();
	}
	
	public static ConnectionUtil getInstance() {
		return SingletonContainer.instance;
	}
	
	public Connection getConnection() {
		return this.conn;
	}
}
